/**
 *-----------------------------------------------------------------------------
 * @file ADCU_HmiService_types.h
 * @brief
 * @author Generator
 * @version 0.0.0.1
 * @date 2023-11-12
 * @note [change history]
 *
 * @copyright GEELY AUTOMOBILE RESEARCH INSTITUTE CO.,LTD Copyright (c) 2023
 *-----------------------------------------------------------------------------
 */
#ifndef GEELY_AP_SERVICES_ADCU_HMISERVICE_ADCU_HMISERVICE_TYPES_H_
#define GEELY_AP_SERVICES_ADCU_HMISERVICE_ADCU_HMISERVICE_TYPES_H_

#include "serialize/Deserializer.h"
#include "serialize/Serializer.h"

struct APAparkInfo {
  uint8_t aPAparkinbuttonSeN__;
  uint8_t aPAparkoutbuttonSeN__;
  uint8_t aPAleftparkSeN__;
  uint8_t aPArightparkSeN__;
  uint8_t aPAparkmodSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, aPAparkinbuttonSeN__ , aPAparkoutbuttonSeN__ , aPAleftparkSeN__ , aPArightparkSeN__ , aPAparkmodSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, aPAparkinbuttonSeN__ , aPAparkoutbuttonSeN__ , aPAleftparkSeN__ , aPArightparkSeN__ , aPAparkmodSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, aPAparkinbuttonSeN__ , aPAparkoutbuttonSeN__ , aPAleftparkSeN__ , aPArightparkSeN__ , aPAparkmodSeN__ );
  }
};

using IdtRet = uint8_t;

using LongitudeType = double;

using Size = uint32_t;

using TLATrafficLightCountdown = int16_t;

using EgoVelocity = float;

using RoadLaneLineColorType = uint8_t;

using InquireFlagType = uint8_t;

using RctaArrowOrientation = uint8_t;

using GnssTimeStampType = uint64_t;

using RiskSectorColor = uint8_t;

using SpplTrfcSgnInfo = uint8_t;

using SpdCoupldSgn3 = uint8_t;

using ID = uint64_t;

using RCATArrowLevel = uint8_t;

using SelectSlotBttonState = uint8_t;

using AlignedSpeedSelType = uint8_t;

using Distance = uint16_t;

using TSIIconFlicker = uint8_t;

using ParkingType = uint8_t;

using RcwAlarmLevel = uint8_t;

using RoadMarkType = uint8_t;

using BreathingLampColor = uint8_t;

using RoadLaneLineWidthType = uint32_t;

using RoadLaneLineCoeffType = double;

using LaneChangeStyleOption = uint8_t;

using ACCState = uint8_t;

using BSDSetting = uint8_t;

using LKAAlarmSetting = uint8_t;

using RapastateType = uint8_t;

using SettingRCTABInfo = uint8_t;

using RiskSectorOrientation = uint8_t;

using Heading = int16_t;

using Shape = uint8_t;

using LatlonType = double;

using SoundEffectType = uint8_t;

using OdomPosition = int32_t;

using IdtNaviStsSeN = int8_t;

using DOWDangerLevelType = uint8_t;

using TSISetting = uint8_t;

using DangerLevel = uint8_t;

using ObjectType = uint8_t;

using AxialAccelerationType = float;

using TLAStarttogo = uint8_t;

using LDPSwitch = uint8_t;

using LaneChangeStatus = uint8_t;

using RoadLaneLineEndType = double;

using Progress = int8_t;

using SlotStatus = uint8_t;

using NzpWarningOption = uint8_t;

using AlarmLevel = uint8_t;

using EnuAngle = double;

using SlotSelectButton = uint8_t;

using SlotType = uint8_t;

using VehiclePosition = int32_t;

using LCCState = uint8_t;

using Angle = int32_t;

using SecondaryPriority = uint16_t;

using SpeedLimitOffsetOption = uint8_t;

using OnOff = uint8_t;

using TSISpeedLimitUnitIcon = uint8_t;

using TSILimitOffset = int8_t;

using ID32bit = uint32_t;

using TSISettingOffsetOption = uint8_t;

using TSINoOvertating = uint8_t;

using VoiceWarningOption = uint8_t;

using RoadLaneLineStartType = double;

using RoadLaneLineRoleType = uint8_t;

using ApaState = uint8_t;

using InsVelocityUpType = float;

using CalendarTime = uint64_t;

using HandsoffWarnType = uint8_t;

using AltitudeType = double;

using Trigger = uint8_t;

using IDM = uint8_t;

using VelocitySpeed = uint16_t;

using InsVelocityEastType = float;

using AlarmProgress = int8_t;

using TSRWarningType = uint8_t;

using Color = uint8_t;

using InsVelocityNorthType = float;

using TurningLight = uint8_t;

using TSISpeedLimitIcon = uint8_t;

using Flag = uint8_t;

using FCWSetting = uint8_t;

using FunctionPendingType = uint8_t;

using LatitudeType = double;

using ParkFlag = uint8_t;

using RoadLaneLineTypeDefine = uint8_t;

using IdtSettingSync = uint8_t;

using LineMarking = uint8_t;

using SignalLamp = uint8_t;

using Calibprogress = uint8_t;

using Time = uint16_t;

using CountDown = uint16_t;

using SpeedLimitOffset = int8_t;

using GreyButton = uint8_t;

using NzpState = uint8_t;

using LightColor = uint8_t;

using LineType = uint8_t;

using RoadLaneLineidType = uint32_t;

using TLATrafficLightLevel = uint8_t;

using NaviStatus = uint8_t;

using PebSwitchType = uint8_t;

using Blink = bool;

using GearStatus = uint8_t;

using ALCAstateType = uint8_t;

using Velocity = uint16_t;

using OnlineCalibTriggerType = uint8_t;

using IsEnable = uint8_t;

using CRCValue = uint8_t;

using WithorWithout = uint8_t;

using DowDangerSource = uint8_t;

using LineCurveTypeDefine = uint8_t;

using CalibItemsType = uint32_t;

using FCTASetting = uint8_t;

struct RCATRisk {
  RCATArrowLevel rCATArrowLevelSeN__;
  RctaArrowOrientation rctaArrowOrientationSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, rCATArrowLevelSeN__ , rctaArrowOrientationSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, rCATArrowLevelSeN__ , rctaArrowOrientationSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, rCATArrowLevelSeN__ , rctaArrowOrientationSeN__ );
  }
};

struct SettingDrivingInfo {
  OnOff nzpSwitchSeN__;
  OnOff changeLaneConfirmSwtichSeN__;
  NzpWarningOption nZPLaneChangeWarning__;
  LaneChangeStyleOption laneChangeStyle__;
  SpeedLimitOffsetOption speedLimitOffsetOptionSeN__;
  SpeedLimitOffset speedLimitOffsetSeN__;
  OnOff lCCSwitchSeN__;
  OnOff aLCSwitch__;
  OnOff autoAlignSpeedLimit__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, nzpSwitchSeN__ , changeLaneConfirmSwtichSeN__ , nZPLaneChangeWarning__ , laneChangeStyle__ , speedLimitOffsetOptionSeN__ , speedLimitOffsetSeN__ , lCCSwitchSeN__ , aLCSwitch__ , autoAlignSpeedLimit__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, nzpSwitchSeN__ , changeLaneConfirmSwtichSeN__ , nZPLaneChangeWarning__ , laneChangeStyle__ , speedLimitOffsetOptionSeN__ , speedLimitOffsetSeN__ , lCCSwitchSeN__ , aLCSwitch__ , autoAlignSpeedLimit__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, nzpSwitchSeN__ , changeLaneConfirmSwtichSeN__ , nZPLaneChangeWarning__ , laneChangeStyle__ , speedLimitOffsetOptionSeN__ , speedLimitOffsetSeN__ , lCCSwitchSeN__ , aLCSwitch__ , autoAlignSpeedLimit__ );
  }
};

struct VehiclePoint {
  VehiclePosition positionXSeN__;
  VehiclePosition positionYSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, positionXSeN__ , positionYSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, positionXSeN__ , positionYSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, positionXSeN__ , positionYSeN__ );
  }
};

struct SettingAEBFCWInfo {
  OnOff aEBFCWGrey__;
  uint8_t aEBFCWswitch__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, aEBFCWGrey__ , aEBFCWswitch__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, aEBFCWGrey__ , aEBFCWswitch__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, aEBFCWGrey__ , aEBFCWswitch__ );
  }
};

struct SettingTLAInfo {
  OnOff tLASwitchSeN__;
  OnOff tLAWarningSwitch__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, tLASwitchSeN__ , tLAWarningSwitch__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, tLASwitchSeN__ , tLAWarningSwitch__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, tLASwitchSeN__ , tLAWarningSwitch__ );
  }
};

struct SettingRPAInfo {
  OnOff rSPASwitchSeN__;
  OnOff rPASwitchSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, rSPASwitchSeN__ , rPASwitchSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, rSPASwitchSeN__ , rPASwitchSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, rSPASwitchSeN__ , rPASwitchSeN__ );
  }
};

struct AbsoluteLocalization {
  LongitudeType longitudeSeN__;
  LatitudeType latitudeSeN__;
  AltitudeType altitudeSeN__;
  EnuAngle yawEnuSeN__;
  EnuAngle pitchEnuSeN__;
  EnuAngle rollEnuSeN__;
  EgoVelocity velocitySeN__;
  InsVelocityEastType insVelocityEastSeN__;
  InsVelocityNorthType insVelocityNorthSeN__;
  InsVelocityUpType insVelocityUpSeN__;
  GnssTimeStampType gnssTimeStampSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, longitudeSeN__ , latitudeSeN__ , altitudeSeN__ , yawEnuSeN__ , pitchEnuSeN__ , rollEnuSeN__ , velocitySeN__ , insVelocityEastSeN__ , insVelocityNorthSeN__ , insVelocityUpSeN__ , gnssTimeStampSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, longitudeSeN__ , latitudeSeN__ , altitudeSeN__ , yawEnuSeN__ , pitchEnuSeN__ , rollEnuSeN__ , velocitySeN__ , insVelocityEastSeN__ , insVelocityNorthSeN__ , insVelocityUpSeN__ , gnssTimeStampSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, longitudeSeN__ , latitudeSeN__ , altitudeSeN__ , yawEnuSeN__ , pitchEnuSeN__ , rollEnuSeN__ , velocitySeN__ , insVelocityEastSeN__ , insVelocityNorthSeN__ , insVelocityUpSeN__ , gnssTimeStampSeN__ );
  }
};

struct AlarmInfo {
  ID32bit alarmIDSeN__;
  AlarmLevel alarmLevelSeN__;
  SecondaryPriority secondaryPrioritySeN__;
  IsEnable dIMTextSeN__;
  IsEnable cSDTextSeN__;
  IsEnable breathingLampSeN__;
  BreathingLampColor breathingLampColorSeN__;
  IsEnable soundEffectSeN__;
  SoundEffectType soundEffectTypeSeN__;
  IsEnable voiceSeN__;
  AlarmProgress progressSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, alarmIDSeN__ , alarmLevelSeN__ , secondaryPrioritySeN__ , dIMTextSeN__ , cSDTextSeN__ , breathingLampSeN__ , breathingLampColorSeN__ , soundEffectSeN__ , soundEffectTypeSeN__ , voiceSeN__ , progressSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, alarmIDSeN__ , alarmLevelSeN__ , secondaryPrioritySeN__ , dIMTextSeN__ , cSDTextSeN__ , breathingLampSeN__ , breathingLampColorSeN__ , soundEffectSeN__ , soundEffectTypeSeN__ , voiceSeN__ , progressSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, alarmIDSeN__ , alarmLevelSeN__ , secondaryPrioritySeN__ , dIMTextSeN__ , cSDTextSeN__ , breathingLampSeN__ , breathingLampColorSeN__ , soundEffectSeN__ , soundEffectTypeSeN__ , voiceSeN__ , progressSeN__ );
  }
};

struct Object {
  ID targetIDSeN__;
  DangerLevel dangerLevelSeN__;
  Heading headingSeN__;
  VehiclePosition centerPositionXSeN__;
  VehiclePosition centerPositionYSeN__;
  Velocity velocitySeN__;
  ObjectType objectTypeSeN__;
  Size sizeXSeN__;
  Size sizeYSeN__;
  Size sizeZSeN__;
  TurningLight turningLightSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, targetIDSeN__ , dangerLevelSeN__ , headingSeN__ , centerPositionXSeN__ , centerPositionYSeN__ , velocitySeN__ , objectTypeSeN__ , sizeXSeN__ , sizeYSeN__ , sizeZSeN__ , turningLightSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, targetIDSeN__ , dangerLevelSeN__ , headingSeN__ , centerPositionXSeN__ , centerPositionYSeN__ , velocitySeN__ , objectTypeSeN__ , sizeXSeN__ , sizeYSeN__ , sizeZSeN__ , turningLightSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, targetIDSeN__ , dangerLevelSeN__ , headingSeN__ , centerPositionXSeN__ , centerPositionYSeN__ , velocitySeN__ , objectTypeSeN__ , sizeXSeN__ , sizeYSeN__ , sizeZSeN__ , turningLightSeN__ );
  }
};

struct IdtSettingCheck {
  WithorWithout settingDataErrorSeN__;
  WithorWithout settingSyncReqSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, settingDataErrorSeN__ , settingSyncReqSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, settingDataErrorSeN__ , settingSyncReqSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, settingDataErrorSeN__ , settingSyncReqSeN__ );
  }
};

struct PathPoint {
  VehiclePosition positionXSeN__;
  VehiclePosition positionYSeN__;
  Angle parkingLinePointTheta__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, positionXSeN__ , positionYSeN__ , parkingLinePointTheta__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, positionXSeN__ , positionYSeN__ , parkingLinePointTheta__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, positionXSeN__ , positionYSeN__ , parkingLinePointTheta__ );
  }
};

struct CoordinateSys {
  VehiclePosition coordinateXSeN__;
  VehiclePosition coordinateYSeN__;
  VehiclePosition coordinateZSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, coordinateXSeN__ , coordinateYSeN__ , coordinateZSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, coordinateXSeN__ , coordinateYSeN__ , coordinateZSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, coordinateXSeN__ , coordinateYSeN__ , coordinateZSeN__ );
  }
};

struct DowRisk {
  DowDangerSource dowDangerSourceSeN__;
  DOWDangerLevelType dOWDangerLevel__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, dowDangerSourceSeN__ , dOWDangerLevel__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, dowDangerSourceSeN__ , dOWDangerLevel__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, dowDangerSourceSeN__ , dOWDangerLevel__ );
  }
};

struct SettingTSIInfo {
  OnOff tSISwitchSeN__;
  TSISetting tSISettingSeN__;
  TSISettingOffsetOption tSISettingOffsetOptionSeN__;
  TSILimitOffset tSILimitOffsetValueSeN__;
  OnOff tSRSwitchSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, tSISwitchSeN__ , tSISettingSeN__ , tSISettingOffsetOptionSeN__ , tSILimitOffsetValueSeN__ , tSRSwitchSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, tSISwitchSeN__ , tSISettingSeN__ , tSISettingOffsetOptionSeN__ , tSILimitOffsetValueSeN__ , tSRSwitchSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, tSISwitchSeN__ , tSISettingSeN__ , tSISettingOffsetOptionSeN__ , tSILimitOffsetValueSeN__ , tSRSwitchSeN__ );
  }
};

struct LatLon {
  LatlonType latSeN__;
  LatlonType lonSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, latSeN__ , lonSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, latSeN__ , lonSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, latSeN__ , lonSeN__ );
  }
};

struct SettingBSDInfo {
  OnOff bSDSwitchSeN__;
  BSDSetting bsdWarningSetting__;
  OnOff cVWSwitch__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, bSDSwitchSeN__ , bsdWarningSetting__ , cVWSwitch__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, bSDSwitchSeN__ , bsdWarningSetting__ , cVWSwitch__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, bSDSwitchSeN__ , bsdWarningSetting__ , cVWSwitch__ );
  }
};

struct SettingFCTAInfo {
  OnOff fCTASwitchSeN__;
  FCTASetting fCTASettingSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, fCTASwitchSeN__ , fCTASettingSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, fCTASwitchSeN__ , fCTASettingSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, fCTASwitchSeN__ , fCTASettingSeN__ );
  }
};

struct IdtDHUInquireIssueLog {
  InquireFlagType inquireFlag__;
  CalendarTime inquireIssueLogTime__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, inquireFlag__ , inquireIssueLogTime__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, inquireFlag__ , inquireIssueLogTime__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, inquireFlag__ , inquireIssueLogTime__ );
  }
};

struct SettingLKAInfo {
  LKAAlarmSetting lDWSettingSeN__;
  LDPSwitch lDPSwitchSeN__;
  OnOff eLKASwitch__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, lDWSettingSeN__ , lDPSwitchSeN__ , eLKASwitch__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, lDWSettingSeN__ , lDPSwitchSeN__ , eLKASwitch__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, lDWSettingSeN__ , lDPSwitchSeN__ , eLKASwitch__ );
  }
};

struct IdtOnlineCalibTrigger {
  OnlineCalibTriggerType onlineCalibTrigger__;
  CalibItemsType calibItems__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, onlineCalibTrigger__ , calibItems__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, onlineCalibTrigger__ , calibItems__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, onlineCalibTrigger__ , calibItems__ );
  }
};

struct IdtSettingInfo {
  CRCValue cRCValueSeN__;
  OnOff nzpSwitchSeN__;
  OnOff changeLaneConfirmSwtichSeN__;
  NzpWarningOption nZPLaneChangeWarning__;
  LaneChangeStyleOption laneChangeStyle__;
  SpeedLimitOffsetOption speedLimitOffsetOptionSeN__;
  SpeedLimitOffset speedLimitOffsetSeN__;
  OnOff lCCSwitchSeN__;
  OnOff aLCSwitch__;
  OnOff autoAlignSpeedLimit__;
  AlignedSpeedSelType alignedSpeedSetting__;
  FCWSetting fCWSettingSeN__;
  OnOff aEBSwitchSeN__;
  LKAAlarmSetting lDWSettingSeN__;
  LDPSwitch lDPSwitchSeN__;
  OnOff eLKASwitch__;
  OnOff fCTASwitchSeN__;
  FCTASetting fCTASettingSeN__;
  OnOff rCTASwitchSeN__;
  OnOff dOWSwitchSeN__;
  OnOff bSDSwitchSeN__;
  BSDSetting bsdWarningSetting__;
  OnOff cVWSwitch__;
  OnOff tSISwitchSeN__;
  TSISetting tSISettingSeN__;
  TSISettingOffsetOption tSISettingOffsetOptionSeN__;
  TSILimitOffset tSILimitOffsetValueSeN__;
  OnOff tSRSwitchSeN__;
  OnOff sRVSwitchSeN__;
  OnOff eMASwitchSeN__;
  OnOff tLASwitchSeN__;
  OnOff tLAWarningSwitch__;
  OnOff cMSRSwitchSeN__;
  VoiceWarningOption voiceWarningOptionSeN__;
  OnOff aPASwitchSeN__;
  OnOff rSPASwitchSeN__;
  OnOff rPASwitchSeN__;
  OnOff lPSwitchSeN__;
  PebSwitchType pebSwitchSetting__;
  OnOff frontVehGoSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, cRCValueSeN__ , nzpSwitchSeN__ , changeLaneConfirmSwtichSeN__ , nZPLaneChangeWarning__ , laneChangeStyle__ , speedLimitOffsetOptionSeN__ , speedLimitOffsetSeN__ , lCCSwitchSeN__ , aLCSwitch__ , autoAlignSpeedLimit__ , alignedSpeedSetting__ , fCWSettingSeN__ , aEBSwitchSeN__ , lDWSettingSeN__ , lDPSwitchSeN__ , eLKASwitch__ , fCTASwitchSeN__ , fCTASettingSeN__ , rCTASwitchSeN__ , dOWSwitchSeN__ , bSDSwitchSeN__ , bsdWarningSetting__ , cVWSwitch__ , tSISwitchSeN__ , tSISettingSeN__ , tSISettingOffsetOptionSeN__ , tSILimitOffsetValueSeN__ , tSRSwitchSeN__ , sRVSwitchSeN__ , eMASwitchSeN__ , tLASwitchSeN__ , tLAWarningSwitch__ , cMSRSwitchSeN__ , voiceWarningOptionSeN__ , aPASwitchSeN__ , rSPASwitchSeN__ , rPASwitchSeN__ , lPSwitchSeN__ , pebSwitchSetting__ , frontVehGoSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, cRCValueSeN__ , nzpSwitchSeN__ , changeLaneConfirmSwtichSeN__ , nZPLaneChangeWarning__ , laneChangeStyle__ , speedLimitOffsetOptionSeN__ , speedLimitOffsetSeN__ , lCCSwitchSeN__ , aLCSwitch__ , autoAlignSpeedLimit__ , alignedSpeedSetting__ , fCWSettingSeN__ , aEBSwitchSeN__ , lDWSettingSeN__ , lDPSwitchSeN__ , eLKASwitch__ , fCTASwitchSeN__ , fCTASettingSeN__ , rCTASwitchSeN__ , dOWSwitchSeN__ , bSDSwitchSeN__ , bsdWarningSetting__ , cVWSwitch__ , tSISwitchSeN__ , tSISettingSeN__ , tSISettingOffsetOptionSeN__ , tSILimitOffsetValueSeN__ , tSRSwitchSeN__ , sRVSwitchSeN__ , eMASwitchSeN__ , tLASwitchSeN__ , tLAWarningSwitch__ , cMSRSwitchSeN__ , voiceWarningOptionSeN__ , aPASwitchSeN__ , rSPASwitchSeN__ , rPASwitchSeN__ , lPSwitchSeN__ , pebSwitchSetting__ , frontVehGoSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, cRCValueSeN__ , nzpSwitchSeN__ , changeLaneConfirmSwtichSeN__ , nZPLaneChangeWarning__ , laneChangeStyle__ , speedLimitOffsetOptionSeN__ , speedLimitOffsetSeN__ , lCCSwitchSeN__ , aLCSwitch__ , autoAlignSpeedLimit__ , alignedSpeedSetting__ , fCWSettingSeN__ , aEBSwitchSeN__ , lDWSettingSeN__ , lDPSwitchSeN__ , eLKASwitch__ , fCTASwitchSeN__ , fCTASettingSeN__ , rCTASwitchSeN__ , dOWSwitchSeN__ , bSDSwitchSeN__ , bsdWarningSetting__ , cVWSwitch__ , tSISwitchSeN__ , tSISettingSeN__ , tSISettingOffsetOptionSeN__ , tSILimitOffsetValueSeN__ , tSRSwitchSeN__ , sRVSwitchSeN__ , eMASwitchSeN__ , tLASwitchSeN__ , tLAWarningSwitch__ , cMSRSwitchSeN__ , voiceWarningOptionSeN__ , aPASwitchSeN__ , rSPASwitchSeN__ , rPASwitchSeN__ , lPSwitchSeN__ , pebSwitchSetting__ , frontVehGoSeN__ );
  }
};

struct BsdRisk {
  RiskSectorColor bsdRiskSectorColor__;
  RiskSectorOrientation bsdRiskSectorOrientation__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, bsdRiskSectorColor__ , bsdRiskSectorOrientation__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, bsdRiskSectorColor__ , bsdRiskSectorOrientation__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, bsdRiskSectorColor__ , bsdRiskSectorOrientation__ );
  }
};

struct RelativeLocalization {
  OdomPosition positionXSeN__;
  OdomPosition positionYSeN__;
  Angle yawSeN__;
  Angle pitchSeN__;
  Angle displayPitchSeN__;
  VehiclePosition targetPoistionXSeN__;
  VehiclePosition targetPoistionYSeN__;
  Progress parkProgressSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, positionXSeN__ , positionYSeN__ , yawSeN__ , pitchSeN__ , displayPitchSeN__ , targetPoistionXSeN__ , targetPoistionYSeN__ , parkProgressSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, positionXSeN__ , positionYSeN__ , yawSeN__ , pitchSeN__ , displayPitchSeN__ , targetPoistionXSeN__ , targetPoistionYSeN__ , parkProgressSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, positionXSeN__ , positionYSeN__ , yawSeN__ , pitchSeN__ , displayPitchSeN__ , targetPoistionXSeN__ , targetPoistionYSeN__ , parkProgressSeN__ );
  }
};

struct SettingAEBInfo {
  FCWSetting fCWSettingSeN__;
  OnOff aEBSwitchSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, fCWSettingSeN__ , aEBSwitchSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, fCWSettingSeN__ , aEBSwitchSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, fCWSettingSeN__ , aEBSwitchSeN__ );
  }
};

struct FctaRisk {
  RiskSectorColor fctaRiskSectorColor__;
  RiskSectorOrientation fctaRiskSectorOrientation__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, fctaRiskSectorColor__ , fctaRiskSectorOrientation__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, fctaRiskSectorColor__ , fctaRiskSectorOrientation__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, fctaRiskSectorColor__ , fctaRiskSectorOrientation__ );
  }
};

struct IdtSettingInitialization {
  IdtSettingSync settingSyncSeN__;
  IdtSettingInfo settingInfoSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, settingSyncSeN__ , settingInfoSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, settingSyncSeN__ , settingInfoSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, settingSyncSeN__ , settingInfoSeN__ );
  }
};

struct Stopline {
  ID stoplineIDSeN__;
  std::vector<VehiclePoint> geometryPointsSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, stoplineIDSeN__ , geometryPointsSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, stoplineIDSeN__ , geometryPointsSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, stoplineIDSeN__ , geometryPointsSeN__ );
  }
};

struct CustomParking {
  ParkingType parkingTypeSeN__;
  std::vector<VehiclePoint> aPAImagePointSeN__;
  ParkFlag customParkFlag__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, parkingTypeSeN__ , aPAImagePointSeN__ , customParkFlag__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, parkingTypeSeN__ , aPAImagePointSeN__ , customParkFlag__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, parkingTypeSeN__ , aPAImagePointSeN__ , customParkFlag__ );
  }
};

struct RoadMark {
  ID roadmarkIDSeN__;
  RoadMarkType roadmarkTypeSeN__;
  std::vector<VehiclePoint> boundaryBoxSeN__;
  std::vector<VehiclePoint> geometryPointsSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, roadmarkIDSeN__ , roadmarkTypeSeN__ , boundaryBoxSeN__ , geometryPointsSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, roadmarkIDSeN__ , roadmarkTypeSeN__ , boundaryBoxSeN__ , geometryPointsSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, roadmarkIDSeN__ , roadmarkTypeSeN__ , boundaryBoxSeN__ , geometryPointsSeN__ );
  }
};

struct EnvRoadLaneLine {
  RoadLaneLineidType roadLaneLineid__;
  RoadLaneLineTypeDefine roadLaneLineType__;
  RoadLaneLineWidthType roadLaneLineWidth__;
  RoadLaneLineRoleType roadLaneLineRole__;
  RoadLaneLineColorType roadLaneLineColor__;
  LineCurveTypeDefine lineCurveType__;
  RoadLaneLineStartType roadLaneLineStart__;
  RoadLaneLineEndType roadLaneLineEnd__;
  std::vector<RoadLaneLineCoeffType> roadLaneLineCoeff__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, roadLaneLineid__ , roadLaneLineType__ , roadLaneLineWidth__ , roadLaneLineRole__ , roadLaneLineColor__ , lineCurveType__ , roadLaneLineStart__ , roadLaneLineEnd__ , roadLaneLineCoeff__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, roadLaneLineid__ , roadLaneLineType__ , roadLaneLineWidth__ , roadLaneLineRole__ , roadLaneLineColor__ , lineCurveType__ , roadLaneLineStart__ , roadLaneLineEnd__ , roadLaneLineCoeff__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, roadLaneLineid__ , roadLaneLineType__ , roadLaneLineWidth__ , roadLaneLineRole__ , roadLaneLineColor__ , lineCurveType__ , roadLaneLineStart__ , roadLaneLineEnd__ , roadLaneLineCoeff__ );
  }
};

struct FeatureState {
  NzpState nzpStateSeN__;
  ApaState apaStateSeN__;
  VelocitySpeed maxCruiseSpeedSeN__;
  std::vector<ID32bit> availableSlotIDSeN__;
  VelocitySpeed laneSpeedLimitSeN__;
  IsEnable timeGapApplyEnableSeN__;
  Time suspendTimeSeN__;
  GreyButton parkContinueButtonSeN__;
  LCCState lCCStateSeN__;
  ACCState aCCStateSeN__;
  RapastateType rapaState__;
  LaneChangeStatus laneChangeStatusSeN__;
  Flag parkingWaitFlagSeN__;
  GearStatus searchingGearStatusSeN__;
  SelectSlotBttonState selectSlotBttonStateSeN__;
  std::vector<FctaRisk> fctaRiskSectorSeN__;
  std::vector<BsdRisk> bsdRiskSectorSeN__;
  std::vector<RCATRisk> rCATArrowSeN__;
  std::vector<DowRisk> dowDangerSeN__;
  RcwAlarmLevel rcwAlarmLevelSeN__;
  TSISpeedLimitIcon tSISpeedLimitIconSeN__;
  TSIIconFlicker tSIIconFlickerSeN__;
  WithorWithout tSIElectronicEyeIconSeN__;
  TSINoOvertating tSINoOvertatingSeN__;
  WithorWithout frontVehGoSeN__;
  WithorWithout tLAFirstVehGNLightSeN__;
  TLATrafficLightCountdown tLATrafficLightCountdownSeN__;
  TLATrafficLightLevel tLATrafficLightLevelSeN__;
  SignalLamp tLALeftSignalLampSeN__;
  SignalLamp tLAStrightSignalLampSeN__;
  SignalLamp tLARightSignalLampSeN__;
  SignalLamp tLATurnSignalLamp__;
  SignalLamp tLATurnLeftSignalLamp__;
  TLAStarttogo tLAStarttogoSeN__;
  TSRWarningType tSRWarningTypeSeN__;
  WithorWithout pEBFaultAlarm__;
  WithorWithout pEBRain__;
  WithorWithout pEBActive__;
  HandsoffWarnType lkaHandsOffWarning__;
  FunctionPendingType functionPending__;
  AxialAccelerationType axialAcceleration__;
  CalibItemsType onlineCalibState__;
  Calibprogress onlineCalibProgress__;
  TSIIconFlicker tSRWarningFlickerSeN__;
  SpdCoupldSgn3 spdLimCoupldFirst__;
  SpplTrfcSgnInfo spdLimSpplFirst__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, nzpStateSeN__ , apaStateSeN__ , maxCruiseSpeedSeN__ , availableSlotIDSeN__ , laneSpeedLimitSeN__ , timeGapApplyEnableSeN__ , suspendTimeSeN__ , parkContinueButtonSeN__ , lCCStateSeN__ , aCCStateSeN__ , rapaState__ , laneChangeStatusSeN__ , parkingWaitFlagSeN__ , searchingGearStatusSeN__ , selectSlotBttonStateSeN__ , fctaRiskSectorSeN__ , bsdRiskSectorSeN__ , rCATArrowSeN__ , dowDangerSeN__ , rcwAlarmLevelSeN__ , tSISpeedLimitIconSeN__ , tSIIconFlickerSeN__ , tSIElectronicEyeIconSeN__ , tSINoOvertatingSeN__ , frontVehGoSeN__ , tLAFirstVehGNLightSeN__ , tLATrafficLightCountdownSeN__ , tLATrafficLightLevelSeN__ , tLALeftSignalLampSeN__ , tLAStrightSignalLampSeN__ , tLARightSignalLampSeN__ , tLATurnSignalLamp__ , tLATurnLeftSignalLamp__ , tLAStarttogoSeN__ , tSRWarningTypeSeN__ , pEBFaultAlarm__ , pEBRain__ , pEBActive__ , lkaHandsOffWarning__ , functionPending__ , axialAcceleration__ , onlineCalibState__ , onlineCalibProgress__ , tSRWarningFlickerSeN__ , spdLimCoupldFirst__ , spdLimSpplFirst__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, nzpStateSeN__ , apaStateSeN__ , maxCruiseSpeedSeN__ , availableSlotIDSeN__ , laneSpeedLimitSeN__ , timeGapApplyEnableSeN__ , suspendTimeSeN__ , parkContinueButtonSeN__ , lCCStateSeN__ , aCCStateSeN__ , rapaState__ , laneChangeStatusSeN__ , parkingWaitFlagSeN__ , searchingGearStatusSeN__ , selectSlotBttonStateSeN__ , fctaRiskSectorSeN__ , bsdRiskSectorSeN__ , rCATArrowSeN__ , dowDangerSeN__ , rcwAlarmLevelSeN__ , tSISpeedLimitIconSeN__ , tSIIconFlickerSeN__ , tSIElectronicEyeIconSeN__ , tSINoOvertatingSeN__ , frontVehGoSeN__ , tLAFirstVehGNLightSeN__ , tLATrafficLightCountdownSeN__ , tLATrafficLightLevelSeN__ , tLALeftSignalLampSeN__ , tLAStrightSignalLampSeN__ , tLARightSignalLampSeN__ , tLATurnSignalLamp__ , tLATurnLeftSignalLamp__ , tLAStarttogoSeN__ , tSRWarningTypeSeN__ , pEBFaultAlarm__ , pEBRain__ , pEBActive__ , lkaHandsOffWarning__ , functionPending__ , axialAcceleration__ , onlineCalibState__ , onlineCalibProgress__ , tSRWarningFlickerSeN__ , spdLimCoupldFirst__ , spdLimSpplFirst__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, nzpStateSeN__ , apaStateSeN__ , maxCruiseSpeedSeN__ , availableSlotIDSeN__ , laneSpeedLimitSeN__ , timeGapApplyEnableSeN__ , suspendTimeSeN__ , parkContinueButtonSeN__ , lCCStateSeN__ , aCCStateSeN__ , rapaState__ , laneChangeStatusSeN__ , parkingWaitFlagSeN__ , searchingGearStatusSeN__ , selectSlotBttonStateSeN__ , fctaRiskSectorSeN__ , bsdRiskSectorSeN__ , rCATArrowSeN__ , dowDangerSeN__ , rcwAlarmLevelSeN__ , tSISpeedLimitIconSeN__ , tSIIconFlickerSeN__ , tSIElectronicEyeIconSeN__ , tSINoOvertatingSeN__ , frontVehGoSeN__ , tLAFirstVehGNLightSeN__ , tLATrafficLightCountdownSeN__ , tLATrafficLightLevelSeN__ , tLALeftSignalLampSeN__ , tLAStrightSignalLampSeN__ , tLARightSignalLampSeN__ , tLATurnSignalLamp__ , tLATurnLeftSignalLamp__ , tLAStarttogoSeN__ , tSRWarningTypeSeN__ , pEBFaultAlarm__ , pEBRain__ , pEBActive__ , lkaHandsOffWarning__ , functionPending__ , axialAcceleration__ , onlineCalibState__ , onlineCalibProgress__ , tSRWarningFlickerSeN__ , spdLimCoupldFirst__ , spdLimSpplFirst__ );
  }
};

struct NavigationInfo {
  ID32bit routeIDSeN__;
  NaviStatus naviStatusSeN__;
  std::vector<LatLon> routeDatasSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, routeIDSeN__ , naviStatusSeN__ , routeDatasSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, routeIDSeN__ , naviStatusSeN__ , routeDatasSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, routeIDSeN__ , naviStatusSeN__ , routeDatasSeN__ );
  }
};

struct PlanningTrajectory {
  std::vector<PathPoint> pathPointsSeN__;
  Distance parkInTrajDistanceSeN__;
  Distance parkInTrajReDistanceSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, pathPointsSeN__ , parkInTrajDistanceSeN__ , parkInTrajReDistanceSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, pathPointsSeN__ , parkInTrajDistanceSeN__ , parkInTrajReDistanceSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, pathPointsSeN__ , parkInTrajDistanceSeN__ , parkInTrajReDistanceSeN__ );
  }
};

struct TrafficLight {
  ID trafficLightIDSeN__;
  std::vector<CoordinateSys> bboxSeN__;
  LightColor redlightSeN__;
  Shape shapeSeN__;
  CountDown countDownSeN__;
  Blink blinkSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, trafficLightIDSeN__ , bboxSeN__ , redlightSeN__ , shapeSeN__ , countDownSeN__ , blinkSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, trafficLightIDSeN__ , bboxSeN__ , redlightSeN__ , shapeSeN__ , countDownSeN__ , blinkSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, trafficLightIDSeN__ , bboxSeN__ , redlightSeN__ , shapeSeN__ , countDownSeN__ , blinkSeN__ );
  }
};

struct Boundary {
  ID boundaryIDSeN__;
  LineType lineTypeSeN__;
  LineMarking lineMarkingSeN__;
  IDM iDMSeN__;
  std::vector<VehiclePoint> geometryPointsSeN__;
  Color boundaryColorSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, boundaryIDSeN__ , lineTypeSeN__ , lineMarkingSeN__ , iDMSeN__ , geometryPointsSeN__ , boundaryColorSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, boundaryIDSeN__ , lineTypeSeN__ , lineMarkingSeN__ , iDMSeN__ , geometryPointsSeN__ , boundaryColorSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, boundaryIDSeN__ , lineTypeSeN__ , lineMarkingSeN__ , iDMSeN__ , geometryPointsSeN__ , boundaryColorSeN__ );
  }
};

struct APASlot {
  ID32bit slotIDSeN__;
  SlotStatus slotStatusSeN__;
  SlotType slotTypeSeN__;
  std::vector<VehiclePoint> slotPointsSeN__;
  std::vector<VehiclePoint> blockPointsSeN__;
  SlotSelectButton slotSelectButtonSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, slotIDSeN__ , slotStatusSeN__ , slotTypeSeN__ , slotPointsSeN__ , blockPointsSeN__ , slotSelectButtonSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, slotIDSeN__ , slotStatusSeN__ , slotTypeSeN__ , slotPointsSeN__ , blockPointsSeN__ , slotSelectButtonSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, slotIDSeN__ , slotStatusSeN__ , slotTypeSeN__ , slotPointsSeN__ , blockPointsSeN__ , slotSelectButtonSeN__ );
  }
};

struct LaneInfo {
  Color laneColorSeN__;
  std::vector<VehiclePoint> leftBoundary__;
  std::vector<VehiclePoint> rightBoundary__;
  std::vector<VehiclePoint> laneAreaSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, laneColorSeN__ , leftBoundary__ , rightBoundary__ , laneAreaSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, laneColorSeN__ , leftBoundary__ , rightBoundary__ , laneAreaSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, laneColorSeN__ , leftBoundary__ , rightBoundary__ , laneAreaSeN__ );
  }
};

struct CrossWalk {
  ID crossWalkIDSeN__;
  std::vector<VehiclePoint> geometryPointsSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, crossWalkIDSeN__ , geometryPointsSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, crossWalkIDSeN__ , geometryPointsSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, crossWalkIDSeN__ , geometryPointsSeN__ );
  }
};

struct HighDefinitionMap {
  std::vector<Boundary> boundariesSeN__;
  std::vector<Stopline> stoplinesSeN__;
  std::vector<CrossWalk> crosswalksSeN__;
  std::vector<RoadMark> roadmarksSeN__;
  LaneInfo targetLaneSeN__;
  using IsStructTag = void;
  uint32_t GetLength(const dra::com::SERIALIZE_TYPE &type) const {
    return dra::com::GetLength(type, boundariesSeN__ , stoplinesSeN__ , crosswalksSeN__ , roadmarksSeN__ , targetLaneSeN__ );
  }
  bool serialize(dra::com::ISerializer *s) const {
    return dra::com::serialize(s, boundariesSeN__ , stoplinesSeN__ , crosswalksSeN__ , roadmarksSeN__ , targetLaneSeN__ );
  }
  bool deserialize(dra::com::IDeserializer *d) {
    return dra::com::deserialize(d, boundariesSeN__ , stoplinesSeN__ , crosswalksSeN__ , roadmarksSeN__ , targetLaneSeN__ );
  }
};

#endif  // GEELY_AP_SERVICES_ADCU_HMISERVICE_ADCU_HMISERVICE_TYPES_H_
